#!/usr/bin/env node

const fs = require("fs");
const path = require("path");

/**
 * 多页面本地化文本替换脚本
 * 使用 web/src/locales/zh-CN/config.js 配置文件
 * 支持多个页面的配置，将项目中的英文文本替换为对应的本地化函数调用
 */

const CONFIG_FILE = "web/src/locales/zh-CN/config.js";

// 检查配置文件是否存在
if (!fs.existsSync(CONFIG_FILE)) {
  console.error(`错误: 配置文件 ${CONFIG_FILE} 不存在`);
  process.exit(1);
}

/**
 * 读取配置文件
 */
function readConfigFile() {
  try {
    // 使用 require 来加载 JavaScript 配置文件
    const config = require(path.resolve(CONFIG_FILE));
    return config;
  } catch (error) {
    console.error(`错误: 无法读取配置文件 ${CONFIG_FILE}:`, error.message);
    process.exit(1);
  }
}

/**
 * 转义正则表达式特殊字符
 */
function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

/**
 * 检查并添加 t 函数的引入
 */
function ensureTranslationImport(text, translationConfig = {}) {
  // 检查是否已经有 t 函数的引入
  const hasTranslationImport =
    /import.*\{.*\bt\b.*\}.*from.*['"]next-intl['"]/i.test(text) ||
    /import.*\{.*\bt\b.*\}.*from.*['"]react-intl['"]/i.test(text) ||
    /import.*\{.*\bt\b.*\}.*from.*['"]i18next['"]/i.test(text) ||
    /import.*\{.*\bt\b.*\}.*from.*['"]@\/src\/utils\/i18n['"]/i.test(text) ||
    /import.*\{.*useTranslation.*\}.*from.*['"]@\/src\/utils\/i18n['"]/i.test(text) ||
    /import.*\bt\b.*from.*['"]next-intl['"]/i.test(text) ||
    /import.*\bt\b.*from.*['"]react-intl['"]/i.test(text) ||
    /import.*\bt\b.*from.*['"]i18next['"]/i.test(text) ||
    /import.*\bt\b.*from.*['"]@\/src\/utils\/i18n['"]/i.test(text) ||
    /const.*\bt\b.*=.*useTranslation/i.test(text) ||
    /const.*\{.*\bt\b.*\}.*=.*useTranslation/i.test(text) ||
    /useTranslations?/i.test(text);

  if (hasTranslationImport) {
    console.log(`   ✅ 已检测到翻译函数引入`);
    return text;
  }

  // 根据配置或自动检测确定翻译库
  let importStatement = "";
  let hookStatement = "";

  if (translationConfig.importStatement) {
    // 使用自定义引入语句
    importStatement = translationConfig.importStatement + "\n";
    // 使用自定义 hook 语句或默认值
    hookStatement = translationConfig.hookStatement || "  const t = useTranslations();\n";
  } else {
    const library = translationConfig.library || "next-intl";

    switch (library) {
      case "next-intl":
        importStatement = "import { useTranslations } from 'next-intl';\n";
        hookStatement = "  const t = useTranslations();\n";
        break;
      case "react-intl":
        importStatement = "import { useIntl } from 'react-intl';\n";
        hookStatement = "  const { formatMessage: t } = useIntl();\n";
        break;
      case "i18next":
        importStatement = "import { useTranslation } from 'react-i18next';\n";
        hookStatement = "  const { t } = useTranslation();\n";
        break;
      case "custom":
        // 自定义翻译库
        importStatement = "import { useTranslation } from '@/src/utils/i18n';\n";
        hookStatement = "  const { t } = useTranslation();\n";
        break;
      default:
        // 自动检测
        const isNextJs = text.includes("next") || text.includes("NextPage") || text.includes("AppProps");
        const isReactComponent = text.includes("React") || text.includes("useState") || text.includes("useEffect");

        if (isNextJs) {
          importStatement = "import { useTranslations } from 'next-intl';\n";
          hookStatement = "  const t = useTranslations();\n";
        } else if (isReactComponent) {
          importStatement = "import { useIntl } from 'react-intl';\n";
          hookStatement = "  const { formatMessage: t } = useIntl();\n";
        } else {
          importStatement = "import { useTranslations } from 'next-intl';\n";
          hookStatement = "  const t = useTranslations();\n";
        }
    }
  }

  // 查找第一个 import 语句的位置
  const importMatch = text.match(/^import\s+/m);
  if (importMatch) {
    // 在第一个 import 后添加
    const insertIndex = text.indexOf(importMatch[0]);
    const beforeImport = text.substring(0, insertIndex);
    const afterImport = text.substring(insertIndex);

    text = beforeImport + importStatement + afterImport;
  } else {
    // 如果没有 import 语句，在文件开头添加
    text = importStatement + text;
  }

  // 添加 hook 调用
  const componentMatch = text.match(/export\s+(default\s+)?function\s+(\w+)/);
  if (componentMatch) {
    const componentName = componentMatch[2];

    // 查找函数体的开始位置
    const functionBodyMatch = text.match(new RegExp(`function\\s+${componentName}\\s*\\([^)]*\\)\\s*{`));
    if (functionBodyMatch) {
      const insertIndex = functionBodyMatch.index + functionBodyMatch[0].length;
      const beforeBody = text.substring(0, insertIndex);
      const afterBody = text.substring(insertIndex);

      text = beforeBody + "\n" + hookStatement + afterBody;
    }
  }

  console.log(`   ✅ 已添加翻译函数引入: ${importStatement.trim()}`);
  return text;
}

/**
 * 在文本中查找并替换所有匹配的key
 */
function replaceInText(text, replacements, translationConfig = {}) {
  let result = text;
  let totalReplacements = 0;
  let needsTranslationImport = false;

  for (const [key, value] of Object.entries(replacements)) {
    // 跳过已经是本地化函数调用的内容（只检查key，不检查value）
    if (key.includes("t(")) {
      continue;
    }

    // 检查是否需要翻译函数引入
    if (value.includes("t(")) {
      needsTranslationImport = true;
    }

    // 检查是否是特殊匹配模式（以 ^ 开头表示忽略缩进）
    if (key.startsWith("^")) {
      const actualKey = key.substring(1); // 去掉 ^ 符号
      const escapedKey = escapeRegExp(actualKey);
      // 匹配任意数量的空格或制表符 + 实际内容
      const pattern = new RegExp(`[ \\t]*${escapedKey}`, "g");
      const matches = result.match(pattern);

      if (matches) {
        // 保持原有的缩进格式
        result = result.replace(pattern, (match) => {
          const indent = match.match(/^[ \t]*/)[0]; // 提取原有的缩进
          return indent + value;
        });
        totalReplacements += matches.length;
        console.log(`   替换(忽略缩进): "${actualKey}" → "${value}" (${matches.length} 次)`);
      }
    } else if (key.startsWith("\\n")) {
      // 多行匹配模式（以 \n 开头）
      const actualKey = key.substring(2); // 去掉 \n 符号
      const escapedKey = escapeRegExp(actualKey);

      // 智能匹配：优先尝试多行属性格式，如果不是则匹配普通多行字符串
      const propertyPattern = new RegExp(`(\\w+:)\\s*\\n\\s*"([^"]*)"`, "g");
      const propertyMatches = result.match(propertyPattern);

      if (propertyMatches) {
        // 多行属性匹配：属性名: 换行 缩进 "字符串"
        let hasPropertyMatch = false;
        result = result.replace(propertyPattern, (match, propertyName, stringContent) => {
          // 如果字符串内容匹配我们的目标
          // actualKey 可能包含 "description:\n  " 前缀，需要提取纯字符串内容
          const keyStringMatch = actualKey.match(/"([^"]*)"/);
          const keyString = keyStringMatch ? keyStringMatch[1] : actualKey;

          if (stringContent === keyString) {
            hasPropertyMatch = true;
            return value; // 直接使用配置中的完整替换值
          }
          return match;
        });
        if (hasPropertyMatch) {
          totalReplacements += 1;
          console.log(`   替换(多行属性): "${actualKey}" → "${value}" (1 次)`);
        }
      } else {
        // 普通多行字符串匹配
        // 修改匹配逻辑：忽略缩进，匹配多行文本
        const lines = actualKey.split("\n");
        const escapedLines = lines.map((line) => escapeRegExp(line.trim()));
        const pattern = new RegExp(`(\\s*)${escapedLines.join("\\s*\\n\\s*")}`, "g");
        const stringMatches = result.match(pattern);

        if (stringMatches) {
          result = result.replace(pattern, (match, indent) => {
            // 保持原有的缩进格式
            return indent + value;
          });
          totalReplacements += stringMatches.length;
          console.log(`   替换(多行字符串): "${actualKey}" → "${value}" (${stringMatches.length} 次)`);
        }
      }
    } else {
      // 直接精确匹配和替换
      const escapedKey = escapeRegExp(key);
      const pattern = new RegExp(escapedKey, "g");
      const matches = result.match(pattern);

      if (matches) {
        result = result.replace(pattern, value);
        totalReplacements += matches.length;
        console.log(`   替换: "${key}" → "${value}" (${matches.length} 次)`);
      }
    }
  }

  // 如果需要翻译函数，确保已引入
  if (needsTranslationImport && totalReplacements > 0 && translationConfig.autoImport !== false) {
    result = ensureTranslationImport(result, translationConfig);
  }

  return { result, totalReplacements };
}

/**
 * 处理单个页面配置
 */
function processPage(pageConfig, globalReplacements = {}, translationConfig = {}) {
  const { name, files, replacements } = pageConfig;
  const pageName = name || files[0]?.split("/").pop() || "未知页面";
  console.log(`\n📄 处理页面: ${pageName}`);

  // 合并全局替换规则和页面特定替换规则
  const allReplacements = { ...globalReplacements, ...replacements };

  console.log(`✅ 加载了 ${Object.keys(allReplacements).length} 个替换规则`);
  for (const [key, value] of Object.entries(allReplacements)) {
    console.log(`   "${key}" → "${value}"`);
  }

  let pageFilesModified = 0;
  let pageTotalReplacements = 0;

  // 处理页面中的所有文件
  for (const targetFile of files) {
    console.log(`\n🔍 检查目标文件: ${targetFile}`);

    if (!fs.existsSync(targetFile)) {
      console.error(`❌ 目标文件 ${targetFile} 不存在`);
      continue;
    }
    console.log(`✅ 目标文件存在: ${targetFile}`);

    try {
      const content = fs.readFileSync(targetFile, "utf8");
      const { result, totalReplacements: fileReplacements } = replaceInText(content, allReplacements, translationConfig);

      if (fileReplacements > 0) {
        console.log(`📝 ${targetFile} (${fileReplacements} 个替换)`);

        // 显示将要进行的替换
        for (const [key, value] of Object.entries(allReplacements)) {
          if (key.startsWith("^")) {
            const actualKey = key.substring(1);
            const pattern = new RegExp(`[ \\t]*${escapeRegExp(actualKey)}`, "g");
            const matches = content.match(pattern);
            if (matches) {
              console.log(`   "${actualKey}" → "${value}" (${matches.length} 次)`);
            }
          } else {
            const pattern = new RegExp(escapeRegExp(key), "g");
            const matches = content.match(pattern);
            if (matches) {
              console.log(`   "${key}" → "${value}" (${matches.length} 次)`);
            }
          }
        }

        // 实际执行替换
        fs.writeFileSync(targetFile, result, "utf8");
        console.log(`   ✅ 已更新文件`);

        pageFilesModified++;
        pageTotalReplacements += fileReplacements;
      } else {
        console.log(`📝 ${targetFile} - 没有找到需要替换的内容`);
      }
    } catch (error) {
      console.error(`❌ 处理文件 ${targetFile} 时出错:`, error.message);
    }
  }

  return { pageFilesModified, pageTotalReplacements };
}

/**
 * 主函数
 */
function main() {
  console.log("🔍 开始多页面本地化文本替换脚本...");
  console.log(`📁 配置文件: ${CONFIG_FILE}`);

  // 读取配置文件
  console.log("\n📖 读取配置文件...");
  const config = readConfigFile();

  if (!config.pages || !Array.isArray(config.pages)) {
    console.error("❌ 配置文件格式错误: 缺少 pages 数组");
    process.exit(1);
  }

  console.log(`✅ 加载了 ${config.pages.length} 个页面配置`);
  for (const page of config.pages) {
    const pageName = page.name || page.files[0]?.split("/").pop() || "未知页面";
    console.log(`   📄 ${pageName} (${page.files.length} 个文件)`);
  }

  // 获取翻译配置
  const translationConfig = config.translation || {};
  if (translationConfig.library) {
    console.log(`\n🌍 翻译库配置: ${translationConfig.library}`);
    console.log(`   自动引入: ${translationConfig.autoImport !== false ? "是" : "否"}`);
  }

  // 获取全局替换规则
  const globalReplacements = config.global?.replacements || {};
  if (Object.keys(globalReplacements).length > 0) {
    console.log(`\n🌍 全局替换规则: ${Object.keys(globalReplacements).length} 个`);
    for (const [key, value] of Object.entries(globalReplacements)) {
      console.log(`   "${key}" → "${value}"`);
    }
  }

  let totalFilesModified = 0;
  let totalReplacements = 0;

  // 处理所有页面
  for (const pageConfig of config.pages) {
    const { pageFilesModified, pageTotalReplacements } = processPage(pageConfig, globalReplacements, translationConfig);
    totalFilesModified += pageFilesModified;
    totalReplacements += pageTotalReplacements;
  }

  // 输出结果
  console.log("\n📊 替换完成!");
  console.log(`📁 修改的文件数: ${totalFilesModified}`);
  console.log(`🔄 总替换次数: ${totalReplacements}`);
  console.log(`📄 处理的页面数: ${config.pages.length}`);
}

// 运行脚本
main();
